package adminservices

import (
	"errors"
	"game-server/app/common/enum"
	"game-server/app/common/request"
	"game-server/app/models"
	"game-server/global"
	"game-server/utils"

	"gorm.io/gorm"
)

type sysUserService struct{}

var SysUserService = new(sysUserService)

// Login 系统用户登录
func (s *sysUserService) Login(params request.SysUserLoginRequest) (*models.SysUser, error) {
	var user models.SysUser
	err := global.App.DB.Where("username = ?", params.Username).First(&user).Error
	if err != nil {
		return nil, errors.New("用户不存在")
	}

	if !utils.BcryptMakeCheck([]byte(params.Password), user.Password) {
		return nil, errors.New("密码错误")
	}

	if user.Status != enum.Enabled {
		return nil, errors.New("用户已被禁用")
	}
	// 清空密码，避免返回给前端
	user.Password = ""

	return &user, nil
}

// 创建系统用户
func (s *sysUserService) SysUserCreate(req request.SysUserCreateRequest) (*models.SysUser, error) {
	// 检查用户名是否已存在
	var count int64
	if err := global.App.DB.Model(&models.SysUser{}).Where("username = ?", req.Username).Count(&count).Error; err != nil {
		return nil, err
	}
	if count > 0 {
		return nil, errors.New("用户名已存在")
	}

	// 创建用户实例
	user := &models.SysUser{
		Username: req.Username,
		Password: utils.BcryptMake([]byte(req.Password)), // 密码加密
		Mobile:   req.Mobile,
		Nickname: req.Nickname,
		Avatar:   req.Avatar,
		Status:   enum.Enabled,
		Email:    req.Email,
	}

	// 开启事务
	err := global.App.DB.Transaction(func(tx *gorm.DB) error {
		// 创建用户
		if err := tx.Create(user).Error; err != nil {
			return err
		}

		// 如果有角色ID，则创建用户角色关联
		if len(req.RoleIds) > 0 {
			var roles []models.SysRole
			if err := tx.Where("id IN ?", req.RoleIds).Find(&roles).Error; err != nil {
				return err
			}
			if err := tx.Model(user).Association("Roles").Replace(roles); err != nil {
				return err
			}
		}

		return nil
	})

	if err != nil {
		return nil, err
	}
	// 清空密码，避免返回给前端
	user.Password = ""

	return user, nil
}

// 获取用户列表
func (s *sysUserService) GetUserList(req request.SysUserListRequest) (list []models.SysUser, total int64, err error) {
	limit := req.PageSize
	offset := req.PageSize * (req.Page - 1)

	// 构建查询
	db := global.App.DB.Model(&models.SysUser{})

	// 条件查询
	if req.Username != "" {
		db = db.Where("username LIKE ?", "%"+req.Username+"%")
	}
	if req.Nickname != "" {
		db = db.Where("nickname LIKE ?", "%"+req.Nickname+"%")
	}
	if req.Mobile != "" {
		db = db.Where("mobile LIKE ?", "%"+req.Mobile+"%")
	}
	if req.Email != "" {
		db = db.Where("email LIKE ?", "%"+req.Email+"%")
	}
	if req.Status != nil {
		db = db.Where("status = ?", *req.Status)
	}

	// 查询总数
	err = db.Count(&total).Error
	if err != nil {
		return nil, 0, err
	}

	// 查询数据
	err = db.Limit(limit).Offset(offset).
		Preload("Roles"). // 预加载角色信息
		Order("id DESC").
		Find(&list).Error
	if err != nil {
		return nil, 0, err
	}

	return list, total, nil
}

// 更新用户
func (s *sysUserService) UpdateUser(req request.SysUserUpdateRequest) error {
	var user models.SysUser
	if err := global.App.DB.First(&user, req.ID).Error; err != nil {
		return errors.New("用户不存在")
	}

	// 如果修改了用户名，需要检查用户名是否已存在
	if req.Username != "" && req.Username != user.Username {
		var count int64
		if err := global.App.DB.Model(&models.SysUser{}).Where("username = ? AND id != ?", req.Username, req.ID).Count(&count).Error; err != nil {
			return err
		}
		if count > 0 {
			return errors.New("用户名已存在")
		}
		user.Username = req.Username
	}

	// 更新其他字段
	if req.Nickname != "" {
		user.Nickname = req.Nickname
	}
	if req.Mobile != "" {
		user.Mobile = req.Mobile
	}
	if req.Avatar != "" {
		user.Avatar = req.Avatar
	}
	if req.Email != "" {
		user.Email = req.Email
	}
	user.Status = req.Status

	return global.App.DB.Transaction(func(tx *gorm.DB) error {
		// 更新用户基本信息
		if err := tx.Save(&user).Error; err != nil {
			return err
		}

		// 建立新的角色关联
		if len(req.RoleIds) > 0 {
			// 如果提供了角色ID，更新用户角色关联
			// 先清除原有的角色关联
			if err := tx.Model(&user).Association("Roles").Clear(); err != nil {
				return err
			}

			var roles []models.SysRole
			if err := tx.Where("id IN ?", req.RoleIds).Find(&roles).Error; err != nil {
				return err
			}
			if err := tx.Model(&user).Association("Roles").Replace(roles); err != nil {
				return err
			}
		}

		return nil
	})
}

// 更新用户状态
func (s *sysUserService) UpdateUserStatus(req request.SysUserStatusRequest) error {
	// 查询用户是否存在
	var user models.SysUser
	if err := global.App.DB.First(&user, req.ID).Error; err != nil {
		return errors.New("用户不存在")
	}

	// 不允许禁用超级管理员
	if user.Type == models.UserTypeAdmin {
		return errors.New("不能禁用超级管理员")
		//todo  待验证
	}

	// 更新状态
	return global.App.DB.Model(&user).Update("status", *req.Status).Error
}

// 根据ID获取用户信息
func (s *sysUserService) GetUserById(id string) (*models.SysUser, error) {
	var user models.SysUser

	err := global.App.DB.Preload("Roles").First(&user, id).Error
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, errors.New("用户不存在")
		}
		return nil, err
	}

	// 清空密码，避免返回给前端
	user.Password = ""

	return &user, nil
}

func (s *sysUserService) DeleteUser(id string) error {
	var user models.SysUser

	// 查询用户是否存在
	if err := global.App.DB.First(&user, id).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			return errors.New("用户不存在")
		}
		return err
	}

	// 不允许删除超级管理员
	if user.Type == models.UserTypeAdmin {
		return errors.New("不能删除超级管理员")
	}

	return global.App.DB.Transaction(func(tx *gorm.DB) error {
		// 删除用户角色关联
		if err := tx.Model(&user).Association("Roles").Clear(); err != nil {
			return err
		}

		// 软删除用户
		if err := tx.Delete(&user).Error; err != nil {
			return err
		}

		return nil
	})
}
